package com.javase.algorithm.datastructure.stringsandarrays;

import com.javase.algorithm.utils.Utils;
import org.omg.PortableInterceptor.SYSTEM_EXCEPTION;

/**
 * 旋转矩阵
 *
 * @author liyanhao
 * @create 2022-07-04 17:40
 * https://leetcode.cn/leetbook/read/array-and-string/clpgd/
 */
public class Rotate {
    public static void main(String[] args) {
        int[][] matrix = new int[3][];//里边标的是数组的长度
        matrix[0] = new int[]{1, 2, 3};
        matrix[1] = new int[]{4, 5, 6};
        matrix[2] = new int[]{7, 8, 9};

        int[][] matrix2 = new int[4][];//里边标的是数组的长度
        matrix2[0] = new int[]{7, 4, 1};
        matrix2[1] = new int[]{8, 5, 2};
        matrix2[2] = new int[]{9, 6, 3};


        //计算位置
        //单个数组的长度是n =3
        //矩阵的高度是h = 3
        //遍历的索引位置是i
        //遍历的层级是 j

        //1,1 旋转之后的位置是 1,3  ==> i,j ==> j,h+1-i
        //1,2 旋转之后的位置是 2,3 ==> i,j ==> j,h+1-i
        //1,3 旋转之后的位置是 3,3==>i,j==>j,h+1-i
        //2,1 旋转之后的位置是 1,2   j,h+1-i
        //2,2 旋转之后的位置是 2,2    j,h+1-i
        //2,3 旋转之后的位置是 3,2   j,h+1-i
        //3,1 旋转之后的位置是 1,1   j,h+1-i
        //3,2 旋转之后的位置是 2,1   j,h+1-i
        //3,3 旋转之后的位置是 3,1   j,h+1-i


        new Rotate().Rotate(matrix);
        System.out.println();
        Utils.printMatrix(matrix);
    }



    public void Rotate(int[][] matrix) {
        //根据矩阵的旋转规律可得
        // 原数组的元素旋转之后的位置为：j,h+1-i
        int lengthH = matrix.length;
        if (lengthH == 0) {
            return;
        }
        int length = matrix[0].length;
        int tmp;
        //循环旋转矩阵 只使用中间变量 不重新创建数组
        int n = matrix[0].length;
        int cycles = length % 2 == 0 ? length / 2 : length / 2 + 1;
        for (int row = 0; row < cycles; row++) {
            for (int column = 0; column < length - column - 1; column++) {
                System.out.println(matrix[row][column]);
                System.out.println(matrix[n - column - 1][row]);
                System.out.println(matrix[n - row - 1][n - column - 1]);
                System.out.println(matrix[column][n - row - 1]);

                tmp = matrix[row][column];
                matrix[row][column] = matrix[n - column - 1][row];
                matrix[n - column - 1][row] = matrix[n - row - 1][n - column - 1];
                matrix[n - row - 1][n - column - 1] = matrix[column][n - row - 1];
                matrix[column][n - row - 1] = tmp;
            }
        }
    }
    public void Rotate2(int[][] matrix) {
        if (matrix != null) {
            return;
        }
        if (matrix[0].length != 0) {
            return;
        }
        //矩阵的长度
        int length = matrix[0].length;
        //矩阵的高度
        int lengthH = matrix.length;

        //旋转需要外层循环的次数
        int cycles= lengthH % 2 == 0 ? length / 2 : length / 2 + 1;
        for (int column = 0; column < cycles; column++) {
            for (int row = 0; row < length - column - 1; row++) {
                int n1 = matrix[row][column];
                int n2 = matrix[length - 1 - column][row];

            }
        }

    }























}
